package com.zyy.study.always;

import org.junit.jupiter.api.Test;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Queue;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

import static org.junit.jupiter.api.Assertions.assertEquals;

public class Code1 {
    @Test
    public void  reverseStringTest() {
        // 你的实现
        assertEquals("olleh", reverseString("hello"));
        //assertEquals("olleh1", reverseString("hello"));
        assertEquals(null, reverseString(null));
    }

    /**
     * 字符串处理
     * 请写一个方法 reverseString，输入一个字符串，返回它的反转形式。
     * 要求：
     *
     * 不使用 StringBuilder.reverse() 或 StringBuffer.reverse()
     * 需处理 null 输入（返回 null）
     * 使用字符数组实现
     * System.out.println(reverseString("hello"));  // 输出 "olleh"
     * System.out.println(reverseString("Java"));   // 输出 "avaJ"
     * System.out.println(reverseString(null));     // 输出 null
     * @param input
     * @return
     */
    public static String reverseString(String input) {
        // 你的实现
        if (input == null) {
            return null;
        }
        char[] charArray = input.toCharArray();
        char[] chars = new char[charArray.length];
        for (int i = 0; i < charArray.length; i++) {
            chars[charArray.length - 1 - i] = charArray[i];
        }
        return new String(chars);
    }

    /**
     * 多线程计数​
     * 用 CountDownLatch 模拟 "运动会赛跑"：
     *
     * 有 ​5名运动员​（线程）准备比赛
     * 所有人准备好后，裁判（主线程）鸣枪开赛
     * 所有运动员跑完后，裁判宣布结束
     *
     * 你的任务：
     * 修改代码使裁判额外做以下操作：
     *
     * 在比赛结束后，​按冲线顺序打印运动员名次​（提示：用线程安全集合记录）
     * 确保打印结果不会出现名次错乱（如：第1名重复或名次跳跃）
     * @throws InterruptedException
     */
    @Test
    public  void CountDownLatchTest() throws InterruptedException {
        final int ATHLETES_COUNT = 5;
        CountDownLatch readyLatch = new CountDownLatch(ATHLETES_COUNT); // 准备就绪计数器
        CountDownLatch startLatch = new CountDownLatch(1);             // 起跑信号
        CountDownLatch finishLatch = new CountDownLatch(ATHLETES_COUNT); // 完成比赛计数器

        ExecutorService executor = Executors.newFixedThreadPool(ATHLETES_COUNT);
        Queue<Integer> queue = new ConcurrentLinkedQueue<Integer>();
        // 创建并提交运动员线程
        for (int i = 1; i <= ATHLETES_COUNT; i++) {
            final int id = i;
            executor.execute(() -> {
                try {
                    // 1. 运动员准备就绪（随机准备0-1秒）
                    Thread.sleep((long)(Math.random() * 1000));
                    System.out.println("运动员 " + id + " 已就位");
                    readyLatch.countDown();

                    // 2. 等待发令枪响
                    startLatch.await();

                    // 3. 开始跑步（随机跑0-2秒）
                    System.out.println("运动员 " + id + " 起跑！");
                    Thread.sleep((long)(Math.random() * 2000));
                    System.out.println("运动员 " + id + " 到达终点！");

                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    // 4. 完成比赛
                    finishLatch.countDown();
                    queue.add(id);
                }
            });
        }

        // 裁判操作
        System.out.println("裁判等待运动员就位...");
        readyLatch.await();     // 等待所有运动员准备就绪
        System.out.println("\n砰！发令枪响！");
        startLatch.countDown(); // 鸣枪开赛

        finishLatch.await();     // 等待所有运动员完成
        System.out.println("\n比赛结束！");
        executor.shutdown();
        int i=1;
        while (!queue.isEmpty()) {
            System.out.println("第"+i +"名："+ queue.poll());
            i++;
        }
    }
}
